home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / touch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  6.6 KB  |  225 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    touchwin
  25. #undef    touchline
  26. #undef    untouchwin
  27. #undef    wtouchln
  28. #undef    is_linetouched
  29. #undef    is_wintouched
  30.  
  31. /* undefine any macros for functions called by this module if in debug mode */
  32. #ifdef PDCDEBUG
  33. #  undef    move
  34. #  undef    wmove
  35. #endif
  36.  
  37. #ifdef PDCDEBUG
  38. char *rcsid_touch  = "$Id$";
  39. #endif
  40.  
  41. /*man-start*********************************************************************
  42.  
  43.   Name:                                                         touch
  44.  
  45.   Synopsis:
  46.       int touchwin(WINDOW *win);
  47.       int touchline(WINDOW *win, int start,int count);
  48.       int untouchwin(WINDOW *win);
  49.       int wtouchln(WINDOW *win, int y, int n, int changed);
  50.       int is_linetouched(WINDOW *win,int line);
  51.       int is_wintouched(WINDOW *win);
  52.  
  53.   X/Open Description:
  54.      The touchwin() and touchline() functions throw away all optimisation 
  55.      information about which parts of the window have been touched, 
  56.      by pretending that the entire window has been drawn on.  
  57.      This is sometimes necessary when using overlapping
  58.      windows, since a change to one window will affect the other window,
  59.      but the records of which lines have been changed in the other
  60.      window will not reflect the change.
  61.  
  62.      The untouchwin() routine marks all lines in the window as unchanged
  63.      since the last call to wrefresh().
  64.  
  65.      The wtouchln() routine makes n lines in the window, starting at 
  66.      line y, look as if they have (changed=1) or have not (changed=0) 
  67.      been changed since the last call to wrefresh().
  68.  
  69.      The is_linetouched() routine returns TRUE if the specified line 
  70.      in the specified window has been changed since the last call to 
  71.      wrefresh(). If the line has not changed, FALSE is returned.
  72.  
  73.      The is_wintouched() routine returns TRUE if the specified window 
  74.      has been changed since the last call to wrefresh(). If the window 
  75.      has not changed, FALSE is returned.
  76.  
  77.   X/Open Return Value:
  78.      All functions return OK on success and ERR on error except
  79.      is_wintouched() and is_linetouched().
  80.  
  81.   X/Open Errors:
  82.      No errors are defined for this function.
  83.  
  84.   Portability                             X/Open    BSD    SYS V
  85.                                           Dec '88
  86.       touchwin                              Y        Y       Y
  87.       touchline                             Y        -      3.0
  88.       untouchwin                            -        -      4.0
  89.       wtouchln                              Y        Y       Y
  90.       is_linetouched                        -        -      4.0
  91.       is_wintouched                         -        -      4.0
  92.  
  93. **man-end**********************************************************************/
  94.  
  95. /***********************************************************************/
  96. int    touchwin(WINDOW *win)
  97. /***********************************************************************/
  98. {
  99.     register int    i;
  100.  
  101. #ifdef PDCDEBUG
  102.     if (trace_on) PDC_debug("touchwin() - called\n");
  103. #endif
  104.  
  105.     if (win == (WINDOW *)NULL)
  106.         return( ERR );
  107.  
  108.     for (i=0;i<win->_maxy;i++)
  109.     {
  110.         win->_firstch[i] = 0;
  111.         win->_lastch[i] = win->_maxx-1;
  112.     }
  113.     return( OK );
  114. }
  115. /***********************************************************************/
  116. int    touchline(WINDOW *win, int start,int count)
  117. /***********************************************************************/
  118. {
  119.     register int i;
  120.  
  121. #ifdef PDCDEBUG
  122.     if (trace_on) PDC_debug("touchline() - called: start %d count %d\n",start,count);
  123. #endif
  124.  
  125.     if (win == (WINDOW *)NULL)
  126.         return( ERR );
  127.  
  128.     if  (start > win->_maxy || start + count > win->_maxy)
  129.         return( ERR );
  130.     for(i=start;i<start+count;i++)
  131.        {
  132.         win->_firstch[i] = 0;
  133.         win->_lastch[i] = win->_maxx - 1;
  134.        }
  135.     return( OK );
  136. }
  137. /***********************************************************************/
  138. int    untouchwin(WINDOW *win)
  139. /***********************************************************************/
  140. {
  141.     register int i;
  142.  
  143. #ifdef PDCDEBUG
  144.     if (trace_on) PDC_debug("untouchwin() - called:");
  145. #endif
  146.  
  147.     if (win == (WINDOW *)NULL)
  148.         return( ERR );
  149.  
  150.     for (i=0;i<win->_maxy;i++)
  151.     {
  152.         win->_firstch[i] = _NO_CHANGE;
  153.         win->_lastch[i] = _NO_CHANGE;
  154.     }
  155.     return(OK);
  156. }
  157. /***********************************************************************/
  158. int    wtouchln(WINDOW *win, int y, int n, int changed)
  159. /***********************************************************************/
  160. {
  161.     register int i;
  162.  
  163. #ifdef PDCDEBUG
  164.     if (trace_on) PDC_debug("wtouchln() - called: y %d n %d changed %d\n",y,n,changed);
  165. #endif
  166.  
  167.     if (win == (WINDOW *)NULL)
  168.         return( ERR );
  169.  
  170.     if  (y > win->_maxy || y + n > win->_maxy)
  171.         return( ERR );
  172.  
  173.     for (i=y;i<y+n;i++)
  174.     {
  175.         if ( changed ) 
  176.         {
  177.             win->_firstch[i] = 0;
  178.             win->_lastch[i] = win->_maxx - 1;
  179.         }
  180.         else 
  181.         {
  182.             win->_firstch[i] = _NO_CHANGE;
  183.             win->_lastch[i] = _NO_CHANGE;
  184.         }
  185.     }
  186.     return( OK );
  187. }
  188. /***********************************************************************/
  189. int    is_linetouched(WINDOW *win,int line)
  190. /***********************************************************************/
  191. {
  192.     register int i;
  193.  
  194. #ifdef PDCDEBUG
  195.     if (trace_on) PDC_debug("is_linetouched() - called\n");
  196. #endif
  197.  
  198.     if (win == NULL)
  199.         return(ERR);
  200.  
  201.     if (line > win->_maxy || line < 0)
  202.         return(ERR);
  203.     if (win->_firstch[line] != _NO_CHANGE) 
  204.         return(TRUE);
  205.     return(FALSE);
  206. }
  207. /***********************************************************************/
  208. int    is_wintouched(WINDOW *win)
  209. /***********************************************************************/
  210. {
  211.     register int i;
  212.  
  213. #ifdef PDCDEBUG
  214.     if (trace_on) PDC_debug("is_wintouched() - called\n");
  215. #endif
  216.  
  217.     if (win == NULL)
  218.         return(ERR);
  219.  
  220.     for (i=0;i<win->_maxy;i++)
  221.         if (win->_firstch[i] != _NO_CHANGE)
  222.             return(TRUE);
  223.     return(FALSE);
  224. }
  225.